home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / pdevtest / RCS / client.c,v < prev    next >
Encoding:
Text File  |  1989-10-24  |  8.0 KB  |  393 lines

  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     89.10.24.12.37.46;  author brent;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     88.04.17.10.20.46;  author brent;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @Client side code for pseudo-device benchmark
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @Updated to new C library, etc.
  28. @
  29. text
  30. @/* 
  31.  * client.c --
  32.  *
  33.  *    The client part of a pseudo-device benchmark.
  34.  *    The routines here interface to the server; initial contact,
  35.  *    waiting for the start message, and notification of completion.
  36.  *
  37.  * Copyright 1986 Regents of the University of California
  38.  * All rights reserved.
  39.  */
  40.  
  41. #ifndef lint
  42. static char rcsid[] = "$Header: /sprite/src/benchmarks/pdevtest/RCS/client.c,v 1.1 88/04/17 10:20:46 brent Exp Locker: brent $ SPRITE (Berkeley)";
  43. #endif not lint
  44.  
  45.  
  46. #include "sprite.h"
  47. #include "status.h"
  48. #include "errno.h"
  49. #include "stdio.h"
  50. #include "fs.h"
  51. #include "sys/file.h"
  52. #include "dev/pdev.h"
  53.  
  54. extern char *pdev;
  55. extern Boolean selectP;
  56.  
  57. static char buffer[4096];
  58. static int bufSize = sizeof(buffer);
  59.  
  60. typedef struct ClientState {
  61.     int clientStreamID;
  62. } ClientState;
  63.  
  64. /*
  65.  *----------------------------------------------------------------------
  66.  *
  67.  * ClientSetup --
  68.  *
  69.  *    Establish contact with the server.
  70.  *
  71.  * Results:
  72.  *    A pointer to state about the clients needed by ClientStart and
  73.  *    ClientDone.
  74.  *
  75.  * Side effects:
  76.  *    Creates named pipes and communicates with server
  77.  *    This exits upon error.
  78.  *
  79.  *----------------------------------------------------------------------
  80.  */
  81.  
  82. void
  83. ClientSetup(dataPtr)
  84.     ClientData *dataPtr;
  85. {
  86.     ClientState *statePtr;
  87.     ReturnStatus status;
  88.  
  89.     statePtr = (ClientState *)malloc(sizeof(ClientState));
  90.  
  91.     statePtr->clientStreamID = open(pdev, O_RDWR, 0);
  92.     if (statePtr->clientStreamID < 0) {
  93.     perror(pdev);
  94.     exit(errno);
  95.     }
  96.     *dataPtr = (ClientData)statePtr;
  97. }
  98.  
  99. /*
  100.  *----------------------------------------------------------------------
  101.  *
  102.  * ClientRead --
  103.  *
  104.  *    Read from a pseudo-device.  The amount and number of repetitions
  105.  *    can be varied for measurment.
  106.  *
  107.  * Results:
  108.  *    None
  109.  *
  110.  * Side effects:
  111.  *    None.
  112.  *
  113.  *----------------------------------------------------------------------
  114.  */
  115.  
  116. void
  117. ClientRead(data, size, reps)
  118.     ClientData data;
  119.     int size;
  120.     register int reps;
  121. {
  122.     ClientState *statePtr;
  123.     int amountRead;
  124.     register ReturnStatus status;
  125.     register char *bufPtr;
  126.     register int i;
  127.  
  128.     if (size > bufSize) {
  129.     bufPtr = (char *)malloc(size);
  130.     } else {
  131.     bufPtr = buffer;
  132.     }
  133.     statePtr = (ClientState *)data;
  134.     for (i=0 ; i<reps ; i++) {
  135.     amountRead = size;
  136.     if (selectP) {
  137.         int numReady;
  138.         int mask = 1 << statePtr->clientStreamID;
  139.         status = Fs_Select(32, NULL, &mask, NULL, NULL, &numReady);
  140.         if (status != SUCCESS) {
  141.         Stat_PrintMsg(status, "ClientRead: error on select");
  142.         break;
  143.         }
  144.     }
  145.     amountRead = read(statePtr->clientStreamID, bufPtr, size);
  146.     if (amountRead < 0) {
  147.         perror("ClientRead: error on read");
  148.         break;
  149.     } else if (amountRead != size) {
  150.         fprintf(stderr, "Read #%d was short (%d < %d)\n",
  151.             i, amountRead, size);
  152.         break;
  153.     }
  154.     if (size > 0 && bufPtr[0] != 'z') {
  155.         fprintf(stderr, "Bad data returned <%c>\n", bufPtr[0]);
  156.     }
  157.     }
  158.     if (bufPtr != buffer) {
  159.     free((char *)bufPtr);
  160.     }
  161. }
  162.  
  163. /*
  164.  *----------------------------------------------------------------------
  165.  *
  166.  * ClientWrite --
  167.  *
  168.  *    Write to a pseudo-device.  The amount and number of repetitions
  169.  *    can be varied for measurment.
  170.  *
  171.  * Results:
  172.  *    None
  173.  *
  174.  * Side effects:
  175.  *    None.
  176.  *
  177.  *----------------------------------------------------------------------
  178.  */
  179.  
  180. void
  181. ClientWrite(data, size, reps)
  182.     ClientData data;
  183.     int size;
  184.     register int reps;
  185. {
  186.     ClientState *statePtr;
  187.     int amountWrite;
  188.     register ReturnStatus status;
  189.     register char *bufPtr;
  190.  
  191.     if (size > bufSize) {
  192.     bufPtr = (char *)malloc(size);
  193.     } else {
  194.     bufPtr = buffer;
  195.     }
  196.     statePtr = (ClientState *)data;
  197.     do {
  198.     amountWrite = write(statePtr->clientStreamID, bufPtr, size);
  199.     if (amountWrite < 0) {
  200.         perror("ClientWrite: error on write");
  201.         break;
  202.     } else if (amountWrite != size) {
  203.         fprintf(stderr, "Short write %d < %d\n", amountWrite,
  204.                     size);
  205.     }
  206.     } while (--reps > 0);
  207.     if (bufPtr != buffer) {
  208.     free((char *)bufPtr);
  209.     }
  210. }
  211.  
  212. /*
  213.  *----------------------------------------------------------------------
  214.  *
  215.  * ClientIOControl --
  216.  *
  217.  *    Do an IOControl to a pseudo-device.
  218.  *    The amount of data passed in and number of repetitions
  219.  *    can be varied for measurment.
  220.  *
  221.  * Results:
  222.  *    None
  223.  *
  224.  * Side effects:
  225.  *    None.
  226.  *
  227.  *----------------------------------------------------------------------
  228.  */
  229.  
  230. void
  231. ClientIOControl(data, size, reps)
  232.     ClientData data;
  233.     int size;
  234.     register int reps;
  235. {
  236.     ClientState *statePtr;
  237.     int amountRead;
  238.     register ReturnStatus status;
  239.     register char *inBuffer;
  240.     register char *outBuffer;
  241.     int command;
  242.  
  243.     if (size > bufSize) {
  244.     inBuffer = (char *)malloc(size);
  245.     outBuffer = (char *)malloc(size);
  246.     } else {
  247.     inBuffer = outBuffer = buffer;
  248.     }
  249.     statePtr = (ClientState *)data;
  250.     do {
  251.     extern Boolean switchBuf;
  252.     if (switchBuf && (reps % 7) == 0) {
  253.         command = IOC_PDEV_SET_BUF;
  254.     } else {
  255.         command = 8 << 16;    /* To avoid range of generic I/O controls */
  256.     }
  257.     status = Fs_IOControl(statePtr->clientStreamID, command, size, inBuffer,
  258.                 size, outBuffer);
  259.     if (status != SUCCESS) {
  260.         Stat_PrintMsg(status, "ClientIOControl: error ");
  261.         break;
  262.     }    
  263.     } while (--reps > 0);
  264.     if (inBuffer != buffer) {
  265.     free((char *)inBuffer);
  266.     free((char *)outBuffer);
  267.     }
  268. }
  269.  
  270. /*
  271.  *----------------------------------------------------------------------
  272.  *
  273.  * ClientDone --
  274.  *
  275.  *    Tell the server we're done.  This is just done by closing
  276.  *    the pseudo stream.
  277.  *
  278.  * Results:
  279.  *    None
  280.  *
  281.  * Side effects:
  282.  *    None
  283.  *
  284.  *----------------------------------------------------------------------
  285.  */
  286.  
  287. void
  288. ClientDone(data)
  289.     ClientData data;
  290. {
  291.     ClientState *statePtr;
  292.     register ReturnStatus status;
  293.  
  294.     statePtr = (ClientState *)data;
  295.     if (close(statePtr->clientStreamID) < 0) {
  296.     perror("ClientDone: error on close");
  297.     }
  298.     free((char *)statePtr);
  299. }
  300. @
  301.  
  302.  
  303. 1.1
  304. log
  305. @Initial revision
  306. @
  307. text
  308. @d4 1
  309. a4 1
  310.  *    The client part of some multi-program synchronization primatives.
  311. d13 1
  312. a13 1
  313. static char rcsid[] = "$Header: client.c,v 1.1 88/04/16 12:27:43 brent Exp $ SPRITE (Berkeley)";
  314. d19 2
  315. a20 1
  316. #include "io.h"
  317. d22 1
  318. d26 1
  319. a26 1
  320. extern Boolean select;
  321. d28 2
  322. a29 2
  323. char buffer[4096];
  324. int bufSize = sizeof(buffer);
  325. d60 1
  326. a60 1
  327.     statePtr = (ClientState *)Mem_Alloc(sizeof(ClientState));
  328. d62 4
  329. a65 6
  330.     status = Fs_Open(pdev, FS_READ|FS_WRITE, 0,
  331.                  &statePtr->clientStreamID);
  332.     if (status != SUCCESS) {
  333.     Stat_PrintMsg(status, "ClientSetup: error opening pseudo device");
  334.     Io_Flush(io_StdErr);
  335.     Proc_Exit(status);
  336. d96 1
  337. a96 1
  338.     register char *buffer = (char *)Mem_Alloc(size);
  339. d99 5
  340. d107 1
  341. a107 1
  342.     if (select) {
  343. d116 3
  344. a118 3
  345.     status = Fs_Read(statePtr->clientStreamID, size, buffer, &amountRead);
  346.     if (status != SUCCESS) {
  347.         Stat_PrintMsg(status, "ClientRead: error on read");
  348. d121 1
  349. a121 1
  350.         Io_PrintStream(io_StdErr, "Read #%d was short (%d < %d)\n",
  351. d125 2
  352. a126 2
  353.     if (size > 0 && buffer[0] != 'z') {
  354.         Io_PrintStream(io_StdErr, "Bad data returned <%c>\n", buffer[0]);
  355. d129 3
  356. a131 1
  357.     Mem_Free(buffer);
  358. d139 1
  359. a139 1
  360.  *    Write from a pseudo-device.  The amount and number of repetitions
  361. d160 1
  362. a160 1
  363.     register char *buffer = (char *)Mem_Alloc(size);
  364. d162 5
  365. d169 3
  366. a171 3
  367.     status = Fs_Write(statePtr->clientStreamID, size, buffer, &amountWrite);
  368.     if (status != SUCCESS) {
  369.         Stat_PrintMsg(status, "ClientWrite: error on read");
  370. d173 2
  371. a174 2
  372.     } if (amountWrite != size) {
  373.         Io_PrintStream(io_StdErr, "Short write %d < %d\n", amountWrite,
  374. d178 3
  375. a180 1
  376.     Mem_Free(buffer);
  377. d210 2
  378. a211 2
  379.     register char *inBuffer = (char *)Mem_Alloc(size);
  380.     register char *outBuffer = (char *)Mem_Alloc(size);
  381. d214 6
  382. d235 4
  383. a238 2
  384.     Mem_Free(inBuffer);
  385.     Mem_Free(outBuffer);
  386. d266 2
  387. a267 3
  388.     status = Fs_Close(statePtr->clientStreamID);
  389.     if (status != SUCCESS) {
  390.     Stat_PrintMsg(status, "ClientDone: error on close");
  391. d269 1
  392. @
  393.